#include"Operator.h"
//1构造
//class Date
//{
//public:
////    Date()//默认构造函数,且这个构造函数不能与全缺省的构造函数同时出现因为全缺也是默认构造，一山不容二虎
////    {
////        _year=2021;
////        _month=10;
////        _day=13;
////    }
//
//    Date(int year,int month,int day)
//    {
//        _year=year;
//        _month=month;
//        _day=day;
//    }
//
//
////    Date(int year=2021,int month=11,int day=4)//缺省参数
////    {
////        _year=year;
////        _month=month;
////        _day=day;
////    }
//    void Print()
//    {
//        cout<<_year<<"/"<<_month<<"/"<<_day<<endl;
//    }
//private:
//    //这个是构造函数的缺省参数
//    int _year=0;
//    int _month=1;
//    int _day=1;
//};
//
//int main()
//{
//    Date d1;
//    d1.Print();
//    Date d2(2002,11,04);
//    d2.Print();
//    return 0;
//
//    //1.如果没写默认构造函数，编译器会自己去调用编译器自带的但是随机值，可以用C++11中的补丁解决，变量缺省
     //如果类中有别的类就会调用他的构造函数，没有和原来的类操作一致
//    //2.全缺省构造函数与默认构造函数只能存在一个
//    //3.默认构造函数是与类名相同无参无返回值的，或者构造函数
//    //4.构造函数支持重载
//    //5.一旦有一个构造函数编译器就不会在生成默认构造了
      //6.构造其实是在初始化不是创建
//}




//2析构
//class Data2
//{
//public:
//    ~Data2()
//    {
//        cout<<"This is ~Data2"<<endl;
//    }
//
//};
//class Date
//{
//public:
//
//    ~Date()
//    {
//        cout<<"This is ~Date"<<endl;
//    }
//    void Print()
//    {
//        cout<<_year<<"/"<<_month<<"/"<<_day<<endl;
//    }
//
//private:
//    //这个是构造函数的缺省参数
//    int _year=0;
//    int _month=1;
//    int _day=1;
//    Data2 c;
//};

//class Stack
//{
//public:
//    Stack()
//    {
//        _a=(int *)malloc (sizeof(int)*4);
//        _top=0;
//        _capacity=4;
//    }
//    ~Stack()
//    {
//        free(_a);
//        _top=0;
//        _capacity=0;
//    }
//
//private:
//    int *_a;
//    int _top;
//    int _capacity;
//};
//int main()
//{
//   // Date d1;
//    Stack s1;
//    Stack s2;
//    return 0;
//
//    //1.析构函数在类中有且只有一个，如果忘记写系统会自动生成
//    //2.编译器自动生成的析构函数啥也不会干，但是类中有别的类会调他的析构韩式，那个析构也没和当前类一样
//   // 3.析构是从下往上调用的，应为他们是存在栈上的，计算机系统的栈也是先进后出
//}


//3.拷贝构造
//class Date
//{
//public:
//
//  Date(int year=2021,int month=11,int day=4)//缺省参数
//  {
//      _year=year;
//      _month=month;
//      _day=day;
//  }
////    Date(const Date& d1)
////    {
////        _year=d1._year;
////        _month=d1._month;
////        _day=d1._day;
////    }
//
//    void Print()
//    {
//        cout<<_year<<"/"<<_month<<"/"<<_day<<endl;
//    }
//
//private:
//    //这个是构造函数的缺省参数
//    int _year=0;
//    int _month=1;
//    int _day=1;
//};
//
//int main()
//{
//    Date d1(2002,11,4);
//    Date d2(d1);
//    d2.Print();
//    //1.拷贝构造是用来初始化非引用类型的参数，那么传实参，到参数形参就是实参的零时拷贝
//    //  那么他就会去调用拷贝函数，但是拷贝函数要考实参又…………，这样就死循环了
//    //2.如果不写编译器会自动生成一个拷贝构造，会一个字节一个字节的拷贝(memcpy),但是不是万能
//   //   动态开辟的空间拷贝会导致俩指针指向同一块空间，结束时调用析构，会释放，那么还有一个类释放他就是重复释放了(越界访问)
//}



void Test()
{
    Date d1;
    Date d2(0,1,1);

          if( d1.operator>=(d2))
      {
          cout<<"true";
      }
      else
      {
          cout<<"false";
      }

    //    d1.Print();
//    d2.Print();
//    d3.Print();
}


void Test2()
{
    Date d1;
//    d1.Print();
//    d1.operator-=(30);
   d1.Print();


    Date ret= d1.operator+(-100);
    ret.Print();
   // cout<<d1.GetMonthDay(2004,2);
}
void Test3()
{
    Date d1;
    d1.Print();
    Date tmp= d1.operator--(021104);
    tmp.Print();
    d1.Print();

}
int main()
{

      //Test3();
     Test2();
     //Test3();



   return 0;
}

